Overview

This presentation covers the following concepts

• Getting started with Git and Github

• The basics of version control systems

• Using Git and Github for collaborative software development

Getting Started with Git & Github

What is Git?

• A decentralized version control system that's free and open source

• An excellent way to track and coordinate file changes among many people

• A filing system for every draft of a document

• A tool invented by Linus Torvalds (and the Linux development community) to develop the Linux kernel in 2005

• The most widely used modern version control system in the world -- by far

• Free software distributed under the terms of the GNU General Public License version 2

• While mainly used for code, Git can be used to manage any type of file/project

  • Word documents

  • Final Cut projects

  • The entire volume of German federal laws

What is GitHub?

• A code sharing and publishing service

• A social networking site for programmers

• The single largest web-based service for hosting Git repositories

• A popular way to collaborate on code (no more emails and zip files!!)

  • The development versions of many R packages are hosted on GitHub: https://github.com/tidyverse/ggplot2

  • All the cool kids are using it!

• Includes several features beyond command-line Git

  • A Web-based graphical interface

  • Task/project management tools

  • A martketplace of integrations for many 3^rd party services

  • Issues!

  • Forking!

Why Should You use Git and GitHub?

For a fast, easy, and stress-free workflow

• Workflows without Git typically consist of

  • Lots of File renaming
  • Absurd folder structures
  • Zipped folders
  • E-mailing files back and forth
  • Lost files
  • Shared directories (one-at-a-time)
  • Ever try merging MS Word files with tracked changes?!

OK, I'm interested in using Git/Github how do I get Started?

Installing Git

• Installing Git is simple - on Mac/Windows/Linux/Unix

  1. Download Git from https://git-scm.com/downloads.
  2. For Mac/Linux/Unix - Accept all installation defaults
  3. For Windows - accept all installation defaults EXCEPT Choose Use Git Bash as the default editor

Setting up a GitHub account

• First, navigate to https://github.com/

• Enter some basic information about your new account

  • A pithy username (hopefully it's still available)
  • An email address (don't use your @afit.edu email)
  • A password

• Set up your profile

Configure Git for first time

• After installing Git and setting up a Github account

  • You need modify the global Git configuration file to tell Git who you are
  • Open a terminal or Git Bash (Windows) and enter the following two lines: (with the obvious modifications)

• Since you passed the option --global, you only need to do this once!

• Now your all set up to use Git & Github!

• However - before we dive too deep into Git, we need to take a step back

  • Git is one of many different version control systems (VCS)

  • It's important to put Git in context

  • You should understand what a VCS is, what types of VCS exist, and how they differ

Understanding Version Control Systems

The Basics of Version Control Systems

What are version control systems?

Why should some use a version control system?

What is a Centralized Version Control System (CVCS)?

What is a Decentralized (aka Distributed) Version Control System (DVCS)?

What are the advantages of using a DVCS instead of a CVCS?

Using Git - Overview

Expectation management - this tutorial won't cover all use cases

• New users often struggle learning how to use Git and conclude that it's too hard

• This misconception is driven by the fact that there seems to be an endless number of use cases

• The issue is NOT that Git is too hard to learn, rather Git is too big to learn

• The fact that Github adds it's own functions makes things even bigger and more complicated

• Remember Git \(\ne\) Github

Many Ways To Use Git

• At the command line

  • Simplest (really!) & fastest
  • Works the same on Windows, Mac, and Linux

• Within an IDE (e.g. RStudio)

  • Convenient when building R packages
  • Can be clunky to update many files

• From a Git desktop GUI

  • Works well for many files
  • Adding another application can interrupt the workflow

• Hybrid method with libgit2

  • Write custom scripts using the git2r package
  • Best option - but comes with a semi-steep learning curve

The basic process of Git

• Initialize Git version tracking in a directory
• Add or edit files in the directory
• Check the status of file changes in the directory
• Add changed files to the staging area
• Commit one or changed files to be updated
• Push commits to the master
• Send pull requests to collaborate with other users
• Add a remote for hosting the files at a URL
• Check out the Git Flow interactive

The basic Git commands you'll use/need

• cd (change directories)
• git init (initialize a folder as a Git repo)
• git add <file-name> (start tracking a new file)
• git commit -m "fix typo" (commit your changes)
• git clone (clone/copy another Git repo [e.g., from GitHub])
• git push origin master (push your master branch to your origin server)
• git pull origin master (update your local repo) Tip: Typing git add --all will start tracking everything (this is how I almost always use git add).

Using Git commands

• Initialize a repo in an existing directory

  • Create a new folder called arithmetic anywhere on your computer (e.g., the Desktop)
  • In this folder, create a new R script file called add.R
  • In this new file add the following code

add <- function(x, y) { x * y }

Initializing a repo in an existing directory

• Next, open a terminal or Git Bash (Windows) and go to the project's root directory

• For example, the code below takes me to the folder called arithmetic on my Desktop

cd C:/Users/greenweb/Desktop/arithmetic

• Then, to initialize this as a Git repo, just type

git init

• This add a new directory called .git within the arithmetic project directory

• If you want to start version controlling all the files, you need to start tracking them. In the terminal, type the following:

• This adds all of the files to the staging area

• Then type the following to commit the file changes

The .git directory

Using Git - Syncing with GitHub

Overview

• Often you'll want to host a local Git repo on Github to use the collaboration tools

• To do this we'll first need to create a new repo on Github

• The name of the Github repo doesn't have to be the same as that of the local repo, but it should

• Next, we'll add the URL of the Github repo as a remote to the local repo

• The remote acts like an online target for pushed changes

• Finally, we'll push the an image of the local repo's current state and the entire change history to the remote

Using Git - Making changes and pushing them to GitHub

Fix the typo

• The function in the add.R file contained a typo

• First, let's fix the obvious typo in add.R

• Now if we run status it should show that one file has been modified

• Then, take a snapshot (i.e., git add/commit) and push the changes to GitHub (i.e., git push)!

• Finally, refresh your browswer and see if it worked!

• Tip: It's good practice to do this every time you make a key change (e.g., fix a typo, add a new function to an R script, etc.).

• Make sure you're in the right directory!

All done!

Any questions?